home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / fbug68k.arc / 68DEF.C next >
C/C++ Source or Header  |  1989-08-16  |  11KB  |  533 lines
  1. #include "userdef.h"
  2.  
  3.  
  4.  
  5. /* ************************************************************************* */
  6. /*                  68def                          */
  7. /* ************************************************************************* */
  8.  
  9. #if(DEVICE==68040 || COPROCESSOR==TRUE)
  10. /* ************************************************************************* */
  11. /* ROUTINE: FPMATCH                                 */
  12. /* ************************************************************************* */
  13.  
  14. int fpmatch(start)
  15. int start;
  16. {
  17. extern error;
  18. extern char sizechar[];
  19.  
  20. int operationword;
  21. int commandword;
  22.  
  23. int type;
  24.  
  25.  
  26. operationword=get16(start);
  27. commandword=get16(start+2);
  28. type = bitnum(8,6,operationword);
  29. if(bitnum(15,9,operationword) != 0x79     /* F-Line reserved         */
  30.     || (type == 0x6)        /* type undefined reserved  */
  31.     || (type == 0x7))        /* type undefined reserved  */
  32.     {
  33.     error = TRUE;
  34.     return(-1);
  35.     }
  36. switch(type)
  37. {
  38.     case 0: /* General Instructions  */
  39.         sizechar[0]='x';    /* As a default to prevent a failure 
  40.                        in disasm68.c */
  41.  
  42.         return(200);    /* A SPECIFIC DETERMINATION WILL 
  43.                    BE MADE IN DISASM68.C    */
  44.     case 1:    /* FDBcc,FScc or FTRAPcc */
  45.         if((bitnum(16,6,commandword) != 0x0) 
  46.             || (bitnum(5,5,commandword) == 0x1))
  47.             {
  48.             error = TRUE;
  49.             return(-1);
  50.             }
  51.         if(bitnum(5,3,operationword) == 0x1)
  52.             {
  53.             return(204);
  54.             }
  55.         else if(bitnum(5,3,operationword) == 0x7) 
  56.             {
  57.             if(bitnum(2,0,operationword) == 0x2)
  58.                 {
  59.                 sizechar[0]='w';
  60.                 return(214);
  61.                 }
  62.             else if(bitnum(2,0,operationword) == 0x3)
  63.                 {
  64.                 sizechar[0]='l';
  65.                 return(214);
  66.                 }
  67.             else if(bitnum(2,0,operationword) == 0x4)
  68.                 return(213);
  69.             }
  70.         sizechar[0]='b';
  71.         return(212);
  72.     case 2: /* FBcc.W */
  73.     case 3: /* FBcc.L */
  74.         if(bitnum(5,5,get16(start))==1)
  75.             {
  76.             error = TRUE;
  77.             return(-1);
  78.             }
  79.         if(type==2 && get16(start+2)==0x0 && bitnum(5,0,operationword)==0x0)
  80.             return(209);
  81.         else if(type==2)
  82.             sizechar[0]='w';
  83.         else
  84.             sizechar[0]='l';
  85.         return(203);
  86.     case 4: /* FSAVE */
  87.         return(211);
  88.     case 5: /* FRESTORE */
  89.         return(210);
  90. }
  91. }
  92. #endif
  93.  
  94. /* ************************************************************************* */
  95.  
  96.  
  97. /* ************************************************************************* */
  98. /* ROUTINE: TABLEMATCH                                 */
  99. /* ************************************************************************* */
  100.  
  101. int tablematch(opword,entry)
  102. int opword;
  103. int entry;
  104. {
  105. extern OPSTRUCTURE syntax1[];
  106. extern int error;
  107. int i,j,Bmatch,a,b,c,maxinstr;
  108.  
  109.  
  110. Bmatch=1;
  111. for(j=15;j>-1;j--)
  112.     {    
  113.     a=syntax1[entry].opwordstr[j] != 'x';
  114.     b=(syntax1[entry].opwordstr[j] == '1' && !(opword & 0x0001));
  115.     c=(syntax1[entry].opwordstr[j] == '0' &&  (opword & 0x0001));
  116.     if(a && (b||c))
  117.         {
  118.             Bmatch=0; /* MATCH FLAG IS SET TO FALSE */
  119.             break;
  120.         }
  121.     opword=opword>>1;
  122.     }
  123. if(Bmatch==0)
  124.     error=TRUE;
  125. return;
  126. }
  127.     
  128.  
  129. /* ************************************************************************* */
  130. /* ROUTINE: BITNUM                                 */
  131. /* ************************************************************************* */
  132.  
  133. int bitnum(startbit,endbit,opword)
  134. int startbit,endbit,opword;
  135. {
  136. int shifted_word,i,value;
  137. value=0;
  138.  
  139. for (i=0;i<=(startbit-endbit);i++)
  140.     {
  141.     shifted_word=(opword>>i+endbit);
  142.     if((shifted_word & 0x1)==1)
  143.         value=value+(1<<i);
  144.     }
  145. return(value);
  146. }
  147.  
  148.     
  149. /* ************************************************************************* */
  150. /*            EFFECTIVE ADDRESS TABLE                     */
  151. /* ************************************************************************* */
  152.  
  153.  
  154.  
  155. struct EA_TABLE
  156. {
  157.     char EAentry[7];
  158. };
  159.  
  160.  
  161. EA_TABLE EffectiveAddrTable[]=
  162. {
  163.     "000xxx",
  164.     "001xxx",
  165.     "010xxx",
  166.     "011xxx",
  167.     "100xxx",
  168.     "101xxx",
  169.     "110xxx",
  170.     "111000",
  171.     "111001",
  172.     "111010",
  173.     "111011",
  174.     "111100"
  175. };
  176.  
  177.  
  178. /* ************************************************************************* */
  179. /* ROUTINE: illegalEA                                 */
  180. /* ************************************************************************* */
  181.  
  182. int illegalEA(EAentry,opword,extensionword)
  183. int EAentry;    /* FROM TABLE CONSISTING OF MASKS */
  184. int opword;
  185. int extensionword;
  186. {
  187. extern EAALLOWED_TYPE EAtype[];
  188. int i,j,matchattempt,Bmatch,allowableEA,a,b,c;
  189. char EAchar;
  190.  
  191. allowableEA=EAtype[EAentry].allowableEA;
  192. matchattempt=opword;
  193. for(i=0;i<12;i++)
  194.     {
  195.     Bmatch=1;
  196.     for(j=5;j>-1;j--)
  197.         {
  198.         EAchar=EffectiveAddrTable[i].EAentry[j];
  199.         a=(EAchar != 'x');
  200.         b=((EAchar == '1') && !(opword & 0x0001));
  201.         c=((EAchar == '0') &&  (opword & 0x0001));
  202.         if(a && (b||c) || (((allowableEA>>(11-i)) & 0x1)==0))
  203.             {
  204.             Bmatch=0;
  205.             break;
  206.             }
  207.         opword=opword>>1;
  208.         }
  209.  
  210.     if(Bmatch==1)
  211.         {
  212.         if(i==6 || i==10)
  213.             {
  214. #if (DEVICE>=68020)
  215.             if((bitnum(8,8,extensionword)==1) &&
  216.      ((bitnum(5,4,extensionword)==0 || bitnum(3,3,extensionword) !=0)||
  217.      (bitnum(6,6,extensionword)==1 && bitnum(2,0,extensionword)  >3) ||
  218.      (bitnum(6,6,extensionword)==1 && bitnum(5,4,extensionword) ==0) ||
  219.      (bitnum(6,6,extensionword)==0 && bitnum(2,0,extensionword) ==4))) 
  220.                 {
  221.                 return(255);
  222.                 }
  223. #else
  224.             if(bitnum(8,8,extensionword)==1)
  225.                 {
  226.                 return(255);
  227.                 }
  228. #endif
  229.             }
  230.         return(i);
  231.         }
  232.     opword=matchattempt;
  233.     }          /* try another EAentry */
  234.     return(255);
  235. }
  236.         
  237.  
  238.  
  239. /* ************************************************************************* */
  240. /* ROUTINE: printEA                                 */
  241. /* ************************************************************************* */
  242.  
  243. printEA(EAentry,EAstartpoint,sizechar,opword)
  244. int EAentry,EAstartpoint;
  245. char sizechar;
  246. int opword;
  247. {
  248. int d16,d8,bd,od,bdsize,odsize,extensionword;
  249. int extension2,immediatedata;
  250. static int scale[4]= {1,2,4,8};
  251. int scalevalue;
  252. static char RegType[2]={'D','A'};
  253. static char WLsize[2]={'W','L'};
  254.  
  255. #if(DEVICE==68040 || COPROCESSOR==TRUE)
  256. int f0_fp,f1_fp,f2_fp;
  257.  
  258. #endif
  259.  
  260. extensionword=get16(EAstartpoint);
  261. bdsize=0;
  262. odsize=0;
  263. switch(EAentry)
  264. {
  265.     case 0:
  266.         print("D%d",bitnum(2,0,opword));
  267.         return;
  268.     case 1:
  269.         print("A%d",bitnum(2,0,opword));
  270.         return;
  271.     case 2:
  272.         print("(A%d)",bitnum(2,0,opword));
  273.         return;
  274.     case 3:
  275.         print("(A%d)+",bitnum(2,0,opword));
  276.         return;
  277.     case 4:
  278.         print("-(A%d)",bitnum(2,0,opword));
  279.         return;
  280.     case 5:
  281.         print("(%c%x,A%d)",HEXDEL,extensionword,bitnum(2,0,opword));
  282.         return;
  283.     case 6:
  284.     case 10:
  285.         switch(bitnum(8,8,extensionword))    
  286.         {
  287.             case 0:        /*BIT 8=0    */
  288.                 if(EAentry==6)
  289.                     print("(%c%x,A%d,",HEXDEL,
  290.                             bitnum(7,0,extensionword),
  291.                         bitnum(2,0,opword));
  292.                 else
  293.                     print("(%c%x,PC,",HEXDEL,
  294.                             bitnum(7,0,extensionword));
  295.                 print("%c%d.%c*%d)",
  296.                 RegType[bitnum(15,15,extensionword)],
  297.                 bitnum(14,12,extensionword),
  298.                 WLsize[bitnum(11,11,extensionword)],
  299.                 scale[bitnum(10,9,extensionword)]);
  300.                 return;
  301.             case 1:        /*BIT 8=1    */
  302.                 switch(bitnum(5,4,extensionword))
  303.                 {
  304.                     case 1:
  305.                         bdsize=0;
  306.                         bd=0;
  307.                         break;
  308.                     case 2:
  309.                         bdsize=2;
  310.                         bd=get16(EAstartpoint+2);
  311.                         break;
  312.                     case 3:
  313.                         bdsize=4;
  314.                         bd=get32(EAstartpoint+2);
  315.                         break;
  316.                 }        
  317.                 if(bitnum(2,0,extensionword)==0)
  318.                     {
  319.                     if(EAentry==6)
  320.                         {
  321.                         print("($%x,",bd);
  322.                         if(bitnum(7,7,extensionword))
  323.                             print("Z");
  324.                         print("A%d,",bitnum(2,0,opword));
  325.                         }
  326.                     else
  327.                         {
  328.                         print("($%x,",bitnum(7,0,extensionword));
  329.                         if(bitnum(7,7,extensionword))
  330.                             print("Z");
  331.                         print("PC,");
  332.                         }
  333.                     if(bitnum(6,6,extensionword))
  334.                         print("Z");
  335.                     print("%c%d.%c*%d)",
  336.                     RegType[bitnum(15,15,extensionword)],
  337.                     bitnum(14,12,extensionword),
  338.                     WLsize[bitnum(11,11,extensionword)],
  339.                     scale[bitnum(10,9,extensionword)]);
  340.                     return;
  341.                     }
  342.                  print("([%c%x,",HEXDEL,bd);
  343.                 if(bitnum(7,7,extensionword))
  344.                      print("Z");
  345.                 if(bitnum(5,3,opword)==6)
  346.                      print("A%d",bitnum(2,0,opword));
  347.                 else
  348.                      print("PC");
  349.                 if(bitnum(2,2,extensionword))
  350.                      print("],");
  351.                 else
  352.                      print(",");
  353.                 if(bitnum(6,6,extensionword))
  354.                      print("Z");
  355.                 if(bitnum(15,15,extensionword))
  356.                      print("A");
  357.                 else
  358.                      print("D");
  359.                  print("%d.%c*%d",bitnum(14,12,extensionword),                        WLsize[bitnum(11,11,extensionword)],                        scale[bitnum(10,9,extensionword)]);
  360.                 switch(bitnum(1,0,extensionword))
  361.                 {
  362.                     case 1:
  363.                         od=0;
  364.                         break;
  365.                     case 2:
  366.                         od=get16(EAstartpoint+2+bdsize);
  367.                         break;
  368.                     case 3:
  369.                         od=get32(EAstartpoint+2+bdsize);
  370.                         break;
  371.                 }
  372.                 if(bitnum(2,2,extensionword))
  373.                      print(",%c%x)",HEXDEL,od);
  374.                 else
  375.                      print("],%c%x)",HEXDEL,od);
  376.                 return;
  377.         }
  378.     case 7:
  379.         print("(%c%x).W",HEXDEL,extensionword);
  380.         return;
  381.     case 8:
  382.         extensionword=extensionword<<16;
  383.         extension2=get16(EAstartpoint+2);
  384.         extensionword=(extensionword | extension2);
  385.         print("(%c%x).L",HEXDEL,extensionword);
  386.         return;
  387.     case 9:
  388.         print("(%c%x,PC)",HEXDEL,extensionword);
  389.         return;
  390.     case 11:
  391.         switch(sizechar)
  392.         {
  393.             case 'b':
  394.             case 'B':
  395.                 immediatedata=(get16(EAstartpoint) & 0xff);
  396.                 break;
  397.             case 'w':
  398.             case 'W':
  399.                 immediatedata=get16(EAstartpoint);
  400.                 break;
  401.             case 'l':
  402.             case 'L':
  403.                 immediatedata=get32(EAstartpoint);
  404.                 break;
  405. #if(DEVICE==68040 || COPROCESSOR==TRUE)
  406.             default:
  407.                 f0_fp=get32(EAstartpoint);
  408.                 f1_fp=get32(EAstartpoint+4);
  409.                 f2_fp=get32(EAstartpoint+8);
  410.                 switch(sizechar)
  411.                     {
  412.                     case 's':
  413.                     case 'S':
  414.                         if(bitnum(31,31,f0_fp))
  415.                             print("-");
  416.                         print("1_%x_E_%x",(bitnum(22,0,f0_fp)<<1),bitnum(30,23,f0_fp)-127);
  417.                         break;
  418.                     case 'd':
  419.                     case 'D':
  420.                         if(bitnum(31,31,f0_fp))
  421.                             print("-");
  422.                         print("1_%x%x_E_%d",bitnum(19,0,f0_fp),bitnum(31,0,f1_fp),bitnum(30,20,f0_fp)-1023);
  423.                         break;
  424.                     case 'x':
  425.                     case 'X':
  426.                         if(bitnum(31,31,f0_fp))
  427.                             print("-");
  428.                         print("%d_%8x%8x_E%d",bitnum(31,31,f1_fp),(bitnum(30,0,f1_fp)<<1),bitnum(31,0,f2_fp),bitnum(30,16,f0_fp)-16383);
  429.                         break;
  430.                     case 'p':
  431.                     case 'P':
  432.                         print("#$");
  433.                         if(bitnum(31,31,f0_fp))
  434.                             print("-");
  435.                         print("%x.%x%x_E",bitnum(3,0,f0_fp),f1_fp,f2_fp);
  436.                         if(bitnum(30,30,f0_fp))
  437.                             print("-");
  438.                         print("%x",bitnum(27,16,f0_fp));
  439.                         break;
  440.                     }
  441.                 return;
  442. #endif
  443.         }
  444.         print("#%c%x",HEXDEL,immediatedata);
  445.         return;
  446. }
  447. }
  448.  
  449. /* ************************************************************************* */
  450. /* ROUTINE: sizeEA                                 */
  451. /* ************************************************************************* */
  452.  
  453.  
  454.  
  455. int sizeEA(EAentry,EAstartpoint,sizechar)
  456. int EAentry,EAstartpoint;
  457. char sizechar;
  458. {
  459. int bdsize,odsize,extensionword;
  460.  
  461. extensionword=get16(EAstartpoint);
  462. switch(EAentry)
  463. {
  464.     case 0: return(0);
  465.     case 1: return(0);
  466.     case 2: return(0);
  467.     case 3: return(0);
  468.     case 4: return(0);
  469.     case 5: return(2);
  470.     case 6:
  471.     case 10:
  472.         switch(bitnum(8,8,extensionword))    
  473.         {
  474.             case 0: return(2);
  475.             case 1:    
  476.                 switch(bitnum(5,4,extensionword))
  477.                 {
  478.                     case 1:
  479.                         bdsize=0;
  480.                         break;
  481.                     case 2:
  482.                         bdsize=2;
  483.                         break;
  484.                     case 3:
  485.                         bdsize=4;
  486.                         break;
  487.                 }        
  488.                 if(bitnum(2,0,extensionword)==0)
  489.                     return(bdsize+2);
  490.                 switch(bitnum(1,0,extensionword))
  491.                 {
  492.                     case 1:
  493.                         odsize=0;
  494.                         break;
  495.                     case 2:
  496.                         odsize=2;
  497.                         break;
  498.                     case 3:
  499.                         odsize=4;
  500.                         break;
  501.                 }
  502.                 return(2+bdsize+odsize);
  503.         }
  504.     case 7: return(2);
  505.     case 8: return(4);
  506.     case 9: return(2);
  507.     case 11: 
  508.         switch(sizechar)
  509.         {
  510.             case 'b':
  511.             case 'B':return(2);
  512.             case 'w':
  513.             case 'W':return(2);
  514.             case 'l':
  515.             case 'L':
  516.             case 's':
  517.             case 'S':return(4);
  518. #if(DEVICE==68040 || COPROCESSOR==TRUE)
  519.             case 'd':
  520.             case 'D':return(8);
  521.             case 'x':
  522.             case 'X':
  523.             case 'p':
  524.             case 'P':return(12);
  525. #endif
  526.         }
  527. }
  528. }
  529.  
  530.  
  531.  
  532.  
  533.